// content_script.js - 极简版AI记忆助手前端插件
// 核心思路：前端只负责捕获和上报，后端负责所有逻辑决策
(function() {
    'use strict'; // 使用严格模式，避免常见错误

    // ========== 配置区 ==========
    // 所有可配置项集中在此处，便于根据实际页面结构调整
    const CONFIG = {
        // DOM选择器（根据通义千问页面结构调整）
        USER_MSG_SELECTOR: '.containerWrap--r2_gRwLP',       // 用户消息气泡的CSS选择器
        AI_MSG_SELECTOR: '.tongyi-markdown',          // AI回复内容的CSS选择器
        AI_MSG_END:'.rightArea--rL5UNOps',              //AI回复内容加载完的css选择器
        AI_MSG_TEXT:'.bubble--OXh8Wwa1',
        MESSAGE_CONTAINER: '#tongyi-content-wrapper', // 对话容器的CSS选择器

        // ANSWER_SELECTOR:'.answerItem--Fjp8fBsN',        //AI回复的根节点
        // QUESTION_SELECTOR:'.questionItem--UrcRIuHd',    // 用户消息气泡的根节点 

        
        // API配置
        API_BASE_URL: 'http://localhost:5000',        // 后端API基础地址
        API_ENDPOINT: '/api/report-message',          // 上报消息的后端API地址
        
        // 性能与容错配置
        DEBOUNCE_DELAY: 1000,       // DOM防抖延迟(ms)，防止频繁触发
    };

    // ========== 状态管理 ==========
    // 前端保持极简状态，只存储必要信息
    let state = {
        messageCount: 0,     // 当前页面消息总数（前端维护的计数）
        isWaiting: false     // 是否正在等待后端响应（防止重复发送）
    };

    // ========== 工具函数 ==========

    /**
     * 获取会话ID（直接从URL参数获取）
     * @returns {string|null} 会话ID或null（如果不存在）
     */
    function getSessionId() {
        const params = new URLSearchParams(window.location.search);
        return params.get('sessionId'); // 直接从URL获取sessionId参数
    }

    /**
     * 统计当前消息总数
     * @returns {number} 页面上的总消息数（用户消息 + AI消息）
     */
    function countMessages() {
        // 分别统计用户消息和AI消息的数量
        const userMsgs = document.querySelectorAll(CONFIG.USER_MSG_SELECTOR).length;
        // const aiMsgs = document.querySelectorAll(CONFIG.AI_MSG_SELECTOR).length;
        const aiMsgs = document.querySelectorAll(CONFIG.AI_MSG_END).length;
        return userMsgs + aiMsgs; // 返回总和
    }

    /**
     * 提取新消息内容（从上次计数到当前计数之间的消息）
     * @param {number} oldCount - 上次记录的消息总数
     * @param {number} newCount - 当前统计的消息总数
     * @returns {Array} 新消息对象数组
     */
    function extractNewMessages(oldCount, newCount) {
        // 获取页面上所有消息元素（用户消息和AI消息）
        const allMessages = document.querySelectorAll(
            `${CONFIG.USER_MSG_SELECTOR}, ${CONFIG.AI_MSG_SELECTOR}`
        );
        
        const newMessages = []; // 存储提取的新消息
        
        // 遍历从oldCount到newCount之间的消息索引
        for (let i = oldCount; i < newCount; i++) {
            console.log(`正在检查消息索引: ${i}, 总消息数: ${newCount}`);
            
            // 确保索引在有效范围内
            if (i < allMessages.length) {
                const msgElement = allMessages[i]; // 获取消息元素
                
                const type = msgElement.matches(CONFIG.USER_MSG_SELECTOR) ? 'user' : 'ai'; // 判断消息类型
             
                // ==== 关键修改1： 延迟获取内容 ======
                let content = "";
                let isComplete = false;

                if(type == 'user'){
                    // 用户消息总是立即完整
                    content = msgElement.textContent.trim();
                    isComplete = true;

                }else if(type == 'ai'){
                    console.log(`这是一条ai消息`);
                    content = msgElement.textContent.trim();
                    isComplete = true;

                    // continue;   //跳过未完成的AI消息
                }else {
                    console.log('这既不是ai消息也不是user消息');
                    continue;
                }
            

                if(content){
                    newMessages.push({
                        type,
                        content,
                        isComplete
                    });
                }
            }
        }
        return newMessages;
    }

    /**
     * 发送数据到后端（核心函数）
     * @param {number} currentCount - 当前消息总数
     * @param {Array} newMessages - 新消息数组
     */
    async function sendToBackend(currentCount, newMessages) {
        // 如果正在等待响应，则直接返回（防止重复发送）
        if (state.isWaiting) return;
        
        state.isWaiting = true; // 标记为等待状态
        
        try {
            console.log(`准备发送 ${newMessages.length} 条消息到后端`);
            
            // 发送POST请求到后端API
            const response = await fetch(CONFIG.API_BASE_URL + CONFIG.API_ENDPOINT, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    session_id: getSessionId(),      // 会话ID
                    current_total: currentCount,      // 当前消息总数
                    new_messages: newMessages        // 新消息数组
                })
            });
            
            // 解析后端响应
            const result = await response.json();
            console.log('后端响应:', result);
            
            // 完全信任后端的决策
            if (result.needReset) {
                // 后端要求重置计数（如页面刷新后）
                console.log(`后端要求重置计数，新基值: ${result.newBaseCount}`);
                state.messageCount = result.newBaseCount;
            }
            // 其他情况无需处理，后端已记录状态

            // // 前端sendToBackend函数中，在收到响应后：
            // console.log('后端响应:', result);
            // if (result.expected_count !== undefined) {
            //     console.log(`前端状态更新: messageCount 从 ${state.messageCount} 更改为 ${result.expected_count}`);
            //     state.messageCount = result.expected_count; // 确保同步后端权威状态
            // }
            
        } catch (error) {
            console.error('发送失败:', error);
        } finally {
            // 无论成功或失败，最后都重置等待状态
            state.isWaiting = false;
        }
    }

    // ========== DOM变化处理 ==========
    let debounceTimer; // 防抖定时器变量



    function handleDOMChanges() {
        clearTimeout(debounceTimer);
        debounceTimer = setTimeout(() => {
            const currentCount = countMessages();
            
            if (currentCount > state.messageCount) {
                // 首先，提取所有新消息（不区分类型）
                const newMessages = extractNewMessages(state.messageCount, currentCount);
                
                // 检查新消息中是否包含AI消息
                const hasAIMessages = newMessages.some(msg => msg.type === 'ai');
                
                if (hasAIMessages) {
                    // 只有当有新AI消息时，才执行完成度检查
                    const aiMessages = document.querySelectorAll(CONFIG.AI_MSG_SELECTOR);
                    let allAIMessagesComplete = true;
                    console.log(`237检测到ai消息等待后续加载，ai消息为`)
                    
                    // 修改后的循环检查部分：
                    for (let i = state.messageCount; i < currentCount; i++) {
                        console.log('验证有没有进行检查循环')
                        // 1. 获取当前索引对应的消息元素（从所有消息中获取）
                        const allMessages = document.querySelectorAll(`${CONFIG.USER_MSG_SELECTOR}, ${CONFIG.AI_MSG_SELECTOR}`);
                        if (i < allMessages.length) {
                            const currentMsgElement = allMessages[i]; // 定义当前消息元素
                            
                            // 2. 只有当该元素是AI消息时，才进行完成度检查
                            if (currentMsgElement.matches(CONFIG.AI_MSG_SELECTOR)) {
                                const hasRightArea = currentMsgElement.querySelector('.rightArea--rL5UNOps') !== null;
                                const hasContent = currentMsgElement.textContent.trim().length > 0;
                                console.log('验证有没有进行完成度检查')
                                if (!hasRightArea || !hasContent) {
                                    console.log('验证有没有进行false操作')
                                    allAIMessagesComplete = false;
                                    break;
                                }
                            }
                        }
                    }
                    
                    if(allAIMessagesComplete){
                        console.log('256验证是否直接发送了消息  allAIMessagesComplete排定为true')
                        // 处理消息
                        sendToBackend(currentCount, newMessages);
                        state.messageCount = currentCount;
                    } else {
                        console.log('验证有没有执行延长等待操作')
                        // 延长等待
                        debounceTimer = setTimeout(() => handleDOMChanges(), 2000);
                    }
                } else {
                    // 如果没有AI消息（只有用户消息），直接处理
                    sendToBackend(currentCount, newMessages);
                    state.messageCount = currentCount;
                }
            }
        }, CONFIG.DEBOUNCE_DELAY);
    }

    // ========== 初始化函数 ==========

    /**
     * 初始化插件
     */
    function init() {
        console.log('正在初始化AI记忆助手插件');
        
        // 获取会话ID
        const sessionId = getSessionId();
        if (!sessionId) {
            console.warn('未找到sessionId参数，插件未启动');
            return;
        }
        console.log(`会话ID: ${sessionId}`);
        
        // 初始化消息计数
        state.messageCount = countMessages();
        console.log(`初始消息计数: ${state.messageCount}`);
        
        // 设置DOM监听
        const container = document.querySelector(CONFIG.MESSAGE_CONTAINER);
        if (container) {
            // 创建MutationObserver监听DOM变化
            const observer = new MutationObserver(handleDOMChanges);
            
            // 配置观察选项：监听子节点变化、子树变化和文本内容变化
            observer.observe(container, {
                childList: true,    // 观察子节点的添加或移除
                subtree: true,      // 观察所有后代节点
                characterData: true // 观察节点内容变化
            });
            
            console.log('AI记忆助手已启动，正在监听DOM变化');
        } else {
            console.error('未找到消息容器，插件启动失败');
        }
    }

    // ========== 启动插件 ==========
    
    // 根据页面加载状态决定初始化时机
    if (document.readyState === 'loading') {
        // 页面仍在加载，等待DOMContentLoaded事件
        document.addEventListener('DOMContentLoaded', init);
    } else {
        // 页面已加载完成，延迟1秒初始化（确保DOM完全渲染）
        setTimeout(init, 1000);
    }
})();


    // USER_ANSWERITEM:'.answerItem--Fjp8fBsN',

    // AI_QUESTIONITEM:'.questionItem--UrcRIuHd'